//if 判断转 switch

const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const t = require("@babel/types");
const generator = require("@babel/generator").default;

const jscode = `function test()
{
    var index = 0,arr = [3, 0, 2, 1],pindex;
    while (1)
    {
        pindex = arr[index++];
        if (pindex<1){
            console.log("this is index 0");
        }else if (pindex<2){
            return;
        }
        else if (pindex<3){
            console.log("this is index 2");
        }   else {
            console.log("Hello world!");
        }
    }
}`; // if转换为switch

const ast = parser.parse(jscode);
const visitor = {
    // WhileStatement(path){
    //     let case_item={};
    //     let discriminant;
    //     function handle(node) {
    //
    //     }
    // }
    'WhileStatement': function (path) {
        let case_item = {}
        let discriminant
        function handle(node) {
            if (t.isIfStatement(node)) {
                let left_name = node.test.left.name  // 获得条件左边变量名称
                if (!eval(left_name) && eval(left_name)!== 0){ // 如果arr数组取索引为undefind就结束循环
                    end_bool=true}
                let right_value = node.test.right.value // 获得条件右边的值
                if (eval(left_name) === right_value) {  // 如果左右相等，就是获得的这个值，放到case_item中
                    case_item[right_value] = node.consequent.body[0] // 定义对象，把代码和数值对应
                } // 如果左右不相等，进行递归，一直找到相等的
                handle(node.alternate) // if 条件是循环相套的，所以需要进行递归
            }
            else {
                case_item['default'] = node.body[0] // 如果不是循环条件，就是else中的值
            }  // 否则对else进行默认处理
        }

        let body2 = path.node.body.body[1]  // 得到循环体
        if (!t.isIfStatement(body2)) {
            return
        }  // 判断类型

        // 获取函数内初始数据，并执行,获得初始变量作用域
        let parentpath = path.parentPath //获取父系节点 BlockStatement
        let body1 = parentpath.node.body[0] //获取父节点中携带的初始化字段
        eval(generator(body1).code)

        discriminant = path.node.body.body[0].expression.right
        let end_bool = false
        while (1) {
            if(end_bool){break}
            let body0 = generator(path.node.body.body[0]).code
            eval(body0) // 执行初始值 pindex = arr[index++];获得条件参数变量作用域
            handle(body2)
        }


        // 构造switch
        let case_list = []
        for (key in case_item){
            if (key !== 'default'){
                console.log(key)
                console.log(case_item[key])
            case_list.push(t.switchCase(t.NumericLiteral(parseInt(key, 10)-1), [case_item[key], t.BreakStatement()]))
        }
        else{
            case_list.push(t.switchCase(undefined,[case_item['default'], t.BreakStatement()]))
            }}
        new_node = t.switchStatement(discriminant, case_list)

        path.get("body.body.1").replaceInline(new_node)
        path.get("body.body.0").remove()
    }

}

traverse(ast, visitor);
console.log(generator(ast)['code'])




